home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / exampleCode / 3Dmodeling / xform.c < prev   
Encoding:
C/C++ Source or Header  |  1994-08-02  |  5.6 KB  |  255 lines
  1. /*
  2.  * Copyright 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17.  
  18. /* Tom Davis -- 1992 */
  19.  
  20. #include <math.h>
  21. #include <stdio.h>
  22.  
  23. #define STACKDEPTH 10
  24.  
  25. typedef struct {
  26.     float    mat[4][4];
  27.     float    norm[3][3];
  28. } mat_t;
  29.  
  30. static mat_t matstack[STACKDEPTH] = {
  31.     {{{1.0, 0.0, 0.0, 0.0},
  32.     {0.0, 1.0, 0.0, 0.0},
  33.     {0.0, 0.0, 1.0, 0.0},
  34.     {0.0, 0.0, 0.0, 1.0}},
  35.     {{1.0, 0.0, 0.0},
  36.     {0.0, 1.0, 0.0},
  37.     {0.0, 0.0, 1.0}}},
  38. };
  39. static long identitymat = 1;
  40.  
  41. static long mattop = 0;
  42.  
  43. void m_resetmatrixstack()
  44. {
  45.     long    i, j;
  46.  
  47.     mattop = 0;
  48.     for (i = 0; i < 4; i++)
  49.     for (j = 0; j < 4; j++)
  50.         matstack[0].mat[i][j] = (i == j) ? 1.0 : 0.0;
  51.     for (i = 0; i < 3; i++)
  52.     for (j = 0; j < 3; j++)
  53.         matstack[0].norm[i][j] = (i == j) ? 1.0 : 0.0;
  54.     identitymat = 1;
  55. }
  56.  
  57. void m_xformpt(float pin[3], float pout[3], float nin[3], float nout[3])
  58. {
  59.     long    i;
  60.     float    ptemp[3], ntemp[3];
  61.     mat_t    *m = &matstack[mattop];
  62.  
  63.     if (identitymat) {
  64.     for (i = 0; i < 3; i++) {
  65.         pout[i] = pin[i];
  66.         nout[i] = nin[i];
  67.     }
  68.     return;
  69.     }
  70.     for (i = 0; i < 3; i++) {
  71.     ptemp[i] = pin[0]*m->mat[0][i] +
  72.            pin[1]*m->mat[1][i] +
  73.            pin[2]*m->mat[2][i] +
  74.            m->mat[3][i];
  75.     ntemp[i] = nin[0]*m->norm[0][i] +
  76.            nin[1]*m->norm[1][i] +
  77.            nin[2]*m->norm[2][i];
  78.     }
  79.     for (i = 0; i < 3; i++) {
  80.     pout[i] = ptemp[i];
  81.     nout[i] = ntemp[i];
  82.     }
  83.     normalize(nout);
  84. }
  85.  
  86. void m_xformptonly(float pin[3], float pout[3])
  87. {
  88.     long    i;
  89.     float    ptemp[3];
  90.     mat_t    *m = &matstack[mattop];
  91.  
  92.     if (identitymat) {
  93.     for (i = 0; i < 3; i++) {
  94.         pout[i] = pin[i];
  95.     }
  96.     return;
  97.     }
  98.      for (i = 0; i < 3; i++) {
  99.     ptemp[i] = pin[0]*m->mat[0][i] +
  100.            pin[1]*m->mat[1][i] +
  101.            pin[2]*m->mat[2][i] +
  102.            m->mat[3][i];
  103.     }
  104.     for (i = 0; i < 3; i++) {
  105.     pout[i] = ptemp[i];
  106.     }
  107. }
  108.  
  109. void m_pushmatrix()
  110. {
  111.     if (mattop < STACKDEPTH-1) {
  112.     matstack[mattop+1] = matstack[mattop];
  113.     mattop++;
  114.     } else
  115.     error("m_pushmatrix: stack overflow\n");
  116. }
  117.  
  118. void m_popmatrix()
  119. {
  120.     if (mattop > 0)
  121.     mattop--;
  122.     else
  123.     error("m_popmatrix: stack underflow\n");
  124. }
  125.  
  126. void m_shear(float xy, float xz, float yz)
  127. {
  128.     long    i;
  129.     mat_t    *m = &matstack[mattop];
  130.     float    temp[4][4];
  131.  
  132.     identitymat = 0;
  133.     for (i = 0; i < 4; i++) {
  134.     temp[0][i] = m->mat[0][i] + xy*m->mat[1][i] + xz*m->mat[2][i];
  135.     temp[1][i] = m->mat[1][i] + yz*m->mat[2][i];
  136.     }
  137.     for (i = 0; i < 4; i++) {
  138.     m->mat[0][i] = temp[0][i];
  139.     m->mat[1][i] = temp[1][i];
  140.     }
  141.     for (i = 0; i < 3; i++) {
  142.     temp[1][i] = -xy*m->norm[0][i] + m->norm[1][i];
  143.     temp[2][i] = (xy*yz-xz)*m->norm[0][i] - yz*m->norm[1][i] + m->norm[2][i];
  144.     }
  145.     for (i = 0; i < 3; i++) {
  146.     m->norm[1][i] = temp[1][i];
  147.     m->norm[2][i] = temp[2][i];
  148.     }
  149. }
  150.  
  151. void m_translate(float x, float y, float z)
  152. {
  153.     long    i;
  154.     mat_t    *m = &matstack[mattop];
  155.  
  156.     identitymat = 0;
  157.     for (i = 0; i < 4; i++)
  158.     m->mat[3][i] = x*m->mat[0][i] +
  159.                  y*m->mat[1][i] +
  160.                  z*m->mat[2][i] +
  161.                  m->mat[3][i];
  162. }
  163.  
  164. void m_scale(float x, float y, float z)
  165. {
  166.     long    i;
  167.     mat_t    *m = &matstack[mattop];
  168.  
  169.     identitymat = 0;
  170.     for (i = 0; i < 3; i++) {
  171.     m->mat[0][i] *= x;
  172.     m->mat[1][i] *= y;
  173.     m->mat[2][i] *= z;
  174.     }
  175.     for (i = 0; i < 3; i++) {
  176.     m->norm[0][i] /= x;
  177.     m->norm[1][i] /= y;
  178.     m->norm[2][i] /= z;
  179.     }
  180. }
  181.  
  182. void m_rotate(float angle, char axis)
  183. {
  184.     float    s, c, temp[4][4];
  185.     mat_t    *m = &matstack[mattop];
  186.     long    i;
  187.  
  188.     identitymat = 0;
  189.     s = sin(angle);
  190.     c = cos(angle);
  191.  
  192.     switch(axis) {
  193.     case 'x':
  194.     case 'X':
  195.         for (i = 0; i < 4; i++) {
  196.         temp[1][i] = c*m->mat[1][i] + s*m->mat[2][i];
  197.         temp[2][i] = -s*m->mat[1][i] + c*m->mat[2][i];
  198.         }
  199.         for (i = 0; i < 4; i++) {
  200.         m->mat[1][i] = temp[1][i];
  201.         m->mat[2][i] = temp[2][i];
  202.         }
  203.         for (i = 0; i < 3; i++) {
  204.         temp[1][i] = c*m->norm[1][i] + s*m->norm[2][i];
  205.         temp[2][i] = -s*m->norm[1][i] + c*m->norm[2][i];
  206.         }
  207.         for (i = 0; i < 3; i++) {
  208.         m->norm[1][i] = temp[1][i];
  209.         m->norm[2][i] = temp[2][i];
  210.         }
  211.         break;
  212.     case 'y':
  213.     case 'Y':
  214.         for (i = 0; i < 4; i++) {
  215.         temp[0][i] = c*m->mat[0][i] + -s*m->mat[2][i];
  216.         temp[2][i] = s*m->mat[0][i] + c*m->mat[2][i];
  217.         }
  218.         for (i = 0; i < 4; i++) {
  219.         m->mat[0][i] = temp[0][i];
  220.         m->mat[2][i] = temp[2][i];
  221.         }
  222.         for (i = 0; i < 3; i++) {
  223.         temp[0][i] = c*m->norm[0][i] + -s*m->norm[2][i];
  224.         temp[2][i] = s*m->norm[0][i] + c*m->norm[2][i];
  225.         }
  226.         for (i = 0; i < 3; i++) {
  227.         m->norm[0][i] = temp[0][i];
  228.         m->norm[2][i] = temp[2][i];
  229.         }
  230.         break;
  231.     case 'z':
  232.     case 'Z':
  233.         for (i = 0; i < 4; i++) {
  234.         temp[0][i] = c*m->mat[0][i] + s*m->mat[1][i];
  235.         temp[1][i] = -s*m->mat[0][i] + c*m->mat[1][i];
  236.         }
  237.         for (i = 0; i < 4; i++) {
  238.         m->mat[0][i] = temp[0][i];
  239.         m->mat[1][i] = temp[1][i];
  240.         }
  241.         for (i = 0; i < 3; i++) {
  242.         temp[0][i] = c*m->norm[0][i] + s*m->norm[1][i];
  243.         temp[1][i] = -s*m->norm[0][i] + c*m->norm[1][i];
  244.         }
  245.         for (i = 0; i < 3; i++) {
  246.         m->norm[0][i] = temp[0][i];
  247.         m->norm[1][i] = temp[1][i];
  248.         }
  249.         break;
  250.     default:
  251.         error("m_rotate: bad axis\n");
  252.         break;
  253.     }
  254. }
  255.